const User = require('../models/user');
const passwordUtils = require('../utils/passwordUtils');
const validationUtils = require('../utils/validationUtils');

/**
 * 用户服务
 * 处理用户相关的业务逻辑
 */
class UserService {
  /**
   * 根据ID获取用户
   * @param {string} userId - 用户ID
   * @returns {Promise<Object>} - 用户信息
   */
  static async getUserById(userId) {
    try {
      // 验证ObjectId格式
      if (!validationUtils.isValidObjectId(userId)) {
        throw new Error('无效的用户ID');
      }
      
      const user = await User.findById(userId).lean();
      
      if (!user) {
        throw new Error('用户不存在');
      }
      
      // 不返回敏感信息
      delete user.password;
      delete user.refreshTokens;
      
      return user;
    } catch (error) {
      throw new Error(`获取用户信息失败: ${error.message}`);
    }
  }
  
  /**
   * 更新用户信息
   * @param {string} userId - 用户ID
   * @param {Object} updateData - 更新数据
   * @returns {Promise<Object>} - 更新后的用户信息
   */
  static async updateUser(userId, updateData) {
    try {
      // 验证ObjectId格式
      if (!validationUtils.isValidObjectId(userId)) {
        throw new Error('无效的用户ID');
      }
      
      // 构建更新对象
      const update = { ...updateData };
      
      // 如果更新邮箱，验证邮箱格式
      if (update.email && !validationUtils.isValidEmail(update.email)) {
        throw new Error('无效的邮箱格式');
      }
      
      // 如果更新手机号，验证手机号格式
      if (update.phone && !validationUtils.isValidPhone(update.phone)) {
        throw new Error('无效的手机号格式');
      }
      
      // 如果更新用户名，验证用户名格式
      if (update.username && !validationUtils.validateUsername(update.username)) {
        throw new Error('无效的用户名格式');
      }
      
      // 检查邮箱是否已被使用
      if (update.email) {
        const existingUser = await User.findOne({ 
          email: update.email, 
          _id: { $ne: userId } 
        });
        
        if (existingUser) {
          throw new Error('邮箱已被使用');
        }
      }
      
      // 更新用户
      const user = await User.findByIdAndUpdate(
        userId,
        update,
        { new: true, runValidators: true }
      ).lean();
      
      if (!user) {
        throw new Error('用户不存在');
      }
      
      // 不返回敏感信息
      delete user.password;
      delete user.refreshTokens;
      
      return user;
    } catch (error) {
      throw new Error(`更新用户信息失败: ${error.message}`);
    }
  }
  
  /**
   * 修改密码
   * @param {string} userId - 用户ID
   * @param {string} currentPassword - 当前密码
   * @param {string} newPassword - 新密码
   * @returns {Promise<boolean>} - 是否修改成功
   */
  static async changePassword(userId, currentPassword, newPassword) {
    try {
      // 验证ObjectId格式
      if (!validationUtils.isValidObjectId(userId)) {
        throw new Error('无效的用户ID');
      }
      
      // 获取用户
      const user = await User.findById(userId);
      
      if (!user) {
        throw new Error('用户不存在');
      }
      
      // 验证当前密码
      const isPasswordValid = await passwordUtils.verifyPassword(
        currentPassword,
        user.password
      );
      
      if (!isPasswordValid) {
        throw new Error('当前密码错误');
      }
      
      // 验证新密码强度
      if (!validationUtils.validatePasswordStrength(newPassword)) {
        throw new Error('密码强度不足，密码必须包含至少8个字符，包括大小写字母、数字和特殊字符');
      }
      
      // 如果新密码和当前密码相同
      if (currentPassword === newPassword) {
        throw new Error('新密码不能与当前密码相同');
      }
      
      // 加密新密码
      const hashedPassword = await passwordUtils.hashPassword(newPassword);
      
      // 更新密码
      await User.findByIdAndUpdate(userId, { password: hashedPassword });
      
      return true;
    } catch (error) {
      throw new Error(`修改密码失败: ${error.message}`);
    }
  }
  
  /**
   * 获取用户列表
   * @param {Object} filters - 过滤条件
   * @param {number} page - 页码
   * @param {number} limit - 每页数量
   * @returns {Promise<Object>} - 用户列表和分页信息
   */
  static async getUsers(filters = {}, page = 1, limit = 10) {
    try {
      // 构建查询条件
      const query = {};
      
      // 搜索条件
      if (filters.search) {
        const searchRegex = new RegExp(filters.search, 'i');
        query.$or = [
          { username: searchRegex },
          { email: searchRegex },
          { phone: searchRegex }
        ];
      }
      
      // 角色过滤
      if (filters.role) {
        query.role = filters.role;
      }
      
      // 状态过滤
      if (filters.status) {
        query.status = filters.status;
      }
      
      // 计算总数
      const total = await User.countDocuments(query);
      
      // 获取分页数据
      const users = await User.find(query)
        .select('-password -refreshTokens')
        .sort({ createdAt: -1 })
        .skip((page - 1) * limit)
        .limit(limit)
        .lean();
      
      return {
        users,
        pagination: {
          total,
          page,
          limit,
          totalPages: Math.ceil(total / limit)
        }
      };
    } catch (error) {
      throw new Error(`获取用户列表失败: ${error.message}`);
    }
  }
  
  /**
   * 删除用户
   * @param {string} userId - 用户ID
   * @returns {Promise<boolean>} - 是否删除成功
   */
  static async deleteUser(userId) {
    try {
      // 验证ObjectId格式
      if (!validationUtils.isValidObjectId(userId)) {
        throw new Error('无效的用户ID');
      }
      
      // 检查用户是否存在
      const user = await User.findById(userId);
      
      if (!user) {
        throw new Error('用户不存在');
      }
      
      // 删除用户
      await User.findByIdAndDelete(userId);
      
      return true;
    } catch (error) {
      throw new Error(`删除用户失败: ${error.message}`);
    }
  }
  
  /**
   * 更新用户状态
   * @param {string} userId - 用户ID
   * @param {string} status - 用户状态 (active/inactive)
   * @returns {Promise<Object>} - 更新后的用户信息
   */
  static async updateUserStatus(userId, status) {
    try {
      // 验证ObjectId格式
      if (!validationUtils.isValidObjectId(userId)) {
        throw new Error('无效的用户ID');
      }
      
      // 验证状态值
      if (!['active', 'inactive'].includes(status)) {
        throw new Error('无效的状态值，状态必须是 active 或 inactive');
      }
      
      // 更新用户状态
      const user = await User.findByIdAndUpdate(
        userId,
        { status },
        { new: true }
      ).select('-password -refreshTokens').lean();
      
      if (!user) {
        throw new Error('用户不存在');
      }
      
      return user;
    } catch (error) {
      throw new Error(`更新用户状态失败: ${error.message}`);
    }
  }
  
  /**
   * 获取用户统计信息
   * @returns {Promise<Object>} - 用户统计信息
   */
  static async getUserStats() {
    try {
      // 获取总用户数
      const totalUsers = await User.countDocuments();
      
      // 获取活跃用户数
      const activeUsers = await User.countDocuments({ status: 'active' });
      
      // 获取非活跃用户数
      const inactiveUsers = await User.countDocuments({ status: 'inactive' });
      
      // 按角色统计用户数
      const usersByRole = await User.aggregate([
        { $group: { _id: '$role', count: { $sum: 1 } } }
      ]);
      
      // 最近30天新注册用户
      const thirtyDaysAgo = new Date();
      thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
      
      const newUsersLast30Days = await User.countDocuments({
        createdAt: { $gte: thirtyDaysAgo }
      });
      
      return {
        totalUsers,
        activeUsers,
        inactiveUsers,
        usersByRole,
        newUsersLast30Days
      };
    } catch (error) {
      throw new Error(`获取用户统计信息失败: ${error.message}`);
    }
  }
}

module.exports = UserService;